בהוראה: הפעולה new מקצה זיכרון עבור עצם בשם s1 המפנה לזיכרון שהוקצה. במקרה זה העצם s1. System.out.println("Enter two numbers:"); String s1;

Transcription

1 פרק 9 המחלקה מחרוזת (String) בתוכניות שכתבנו עד כה השתמשנו בטיפוסים שונים המוגדרים בשפת :Java שלם, ממשי, תווי ובוליאני. יכולנו להגדיר משתנים מטיפוסים אלו ולבצע עליהם פעולות שונות (קלט, פלט, חישובים וכו'). עם זאת מרבית התוכניות שכתבנו התייחסו גם למחרוזות, סדרות של תווים. עד עתה השתמשנו במחרוזות כאשר רצינו להדפיס הודעות למשתמש ותחמנו אותן בגרשיים, למשל בהוראה: System.out.println("Enter two numbers:"); ההודעה numbers:" "Enter two היא מחרוזת. הנה דוגמאות נוספות למחרוזות בשפת,"J","453","Hello, How Are You?" :Java "" (האחרונה היא מחרוזת ריקה, שאינה מכילה אף תו). בנוסף להדפסה נרצה לעתים להפעיל על מחרוזות פעולות נוספות. בפרק זה נראה כיצד ניתן לקלוט מחרוזות מהמשתמש, ולעבד אותן. אם עד עתה קלטנו מספרים או תווים בודדים בלבד, עכשיו נוכל לבקש מהמשתמש להקיש את שמו, את כתובתו וכדומה ולבצע פעולות שונות על המחרוזות הנקלטות. 9.1 היכרות ראשונית עם המחלקה String מחלקה (class) מגדירה טיפוס חדש, ועצם (object) הוא משתנה מהטיפוס. עצם אינו משתנה פשוט כמו int או כמו char אלא מופע (instance) של מחלקה שאפשר להפעיל עליו פעולות המוגדרות במחלקה. בשפת Java מוגדרת מחלקה בשם String (מחרוזת). הצהרה על משתנה מטיפוס מחרוזת מתבצעת כך: String s1; אמנם הצהרה על עצמים דומה להצהרה על משתנים מטיפוסים רגילים. אבל בשונה ממשתנים מטיפוסים רגילים, עלינו ליצור עצמים. יצירת עצם כוללת הקצאת שטח בזיכרון עבור העצם ואת אתחולו. עבור משתנים רגילים, הקצאת מקום בזיכרון נעשית אוטומטית עם ההצהרה עליהם ואילו עבור עצמים הקצאת הזיכרון והאתחול מתבצעים באמצעות הפעולה,new למשל כך: s1 = new String(); הפעולה new מקצה זיכרון עבור עצם בשם s1 המפנה לזיכרון שהוקצה. במקרה זה העצם s1 מאותחל במחרוזת ריקה "". אם נרצה לאתחל את העצם בערך כלשהו, נוכל לעשות זאת בציון הערך הרצוי בזמן היצירה, למשל כך: s1 = new String("abc"); כעת העצם s1 מפנה לשטח בזיכרון המכיל את המחרוזת."abc" מכיוון שהשימוש במחרוזות נפוץ כל כך, שפת Java מאפשרת ליצור מחרוזת ולאתחל אותה בצורה ישירה ללא שימוש בפעולה.new למשל, כך: s1 = "xyz"; יצירת מחרוזת בצורה זו מקצה זיכרון עבור המחרוזת s1, ומאתחל אותה ב-" xyz "

2 בדומה למשתנים פשוטים, אפשר לאחד את ההצהרה ואת היצירה כך: או כך: String s1 = new String("hello"); בהמשך הפרק נכיר פעולות שונות שאפשר לבצע על עצמים מטיפוס.String String s2 = "good morning"; בשפת Java מחרוזת היא עצם של המחלקה.String הצהרה על מחרוזות מתבצעת באופן דומה להצהרה על משתנים רגילים, למשל: כדי שניתן יהיה להשתמש בעצם מהמחלקה מחרוזת, יש ליצור את העצם. כוללת הקצאת שטח בזיכרון ואתחול העצם. במקרה של עצם מסוג,String אפשר ליצור אותו באמצעות הפעולה :new או באמצעות השמה פשוטה של סדרת תווים בגרשיים: String s1; יצירת העצם String s1 = new String("hello"); String s2 = "good morning"; בעיה 1 מטרת הבעיה ופתרונה: הצגת קלט של מחרוזת. פתחו וישמו אלגוריתם שיקבל כקלט את שמכם ויציג is: Your name ומיד שנקלט. אחר כך את השם חירת משתנים? ב באיזה טיפוס נשתמש כדי לשמור את השם שנקלט? כיוון שעלינו לקלוט מילה נשתמש במחלקה מחרוזת. אם כך רשימת המשתנים תכלול את העצם name מהמחלקה מחרוזת. האלגוריתם: name-á úæåøçî èåì "Your name is: " èìôë âöä name úà èìôë âöä יישום האלגוריתם עד כה ראינו כיצד לקלוט ערכים מטיפוסים פשוטים שלמים, ממשיים ותווים. קליטת מחרוזת נעשית בצורה דומה. את הוראה 1 נוכל לממש במשפטים: Scanner in = new Scanner(System.in); name = in.nextline(); הפעולה nextline קולטת את כל התווים עד סוף השורה ומחזירה עצם מסוג מחרוזת. למשל אם המשתמש הקליד: my name is Moshe - 2 -

3 העצם name יכיל את המחרוזת: Moshe" "my name is התוכנית המלאה /* הנקלט כמחרוזת שם, קלט: מלווה בהודעה מקדימה */ השם, פלט: import java.util.scanner; public class YourName public static void main (String [] args) name; String // עצם מהמחלקה מחרוזת הצהרה על Scanner in = new Scanner(System.in); הקצאת מקום בזיכרון // + הוראת קלט System.out.print("Enter your name: "); name = in.nextline(); פלט // System.out.println("your name is: " + name); } // main } // class YourName שימו : כמו פעולות קלט לערכים מטיפוסים פשוטים, גם פעולת קלט למחרוזת היא למעשה פעולה המחזירה את הערך הנקלט. הפעולה קולטת מחרוזת מהקלט, ויוצרת עצם חדש מהמחלקה מחרוזת. פעולת הקלט מקצה עבורו מקום בזיכרון ושומרת בו את מחרוזת הקלט. הפעולה in.nextline מחזירה הפניה למחרוזת החדשה שהוקצתה. בעת ביצוע ההוראה: name = in.nextline(); אנו מבצעים השמה של המחרוזת הנקלטת במשתנה.name בעקבות ההשמה מ פ נ ה name אל אותו שטח זיכרון שהוקצה על ידי פעולת הקלט ולכן אין צורך להקצות במפורש שטח זיכרון עבור העצם.name פתרון בעיה סוף 1 בפתרון בעיה 1 הראינו כיצד קולטים מחרוזת באמצעות הפעולה nextline של המחלקה.Scanner פעולה זו קולטת מהמשתמש מחרוזת המסתיימת בסוף השורה. קיימת פעולה נוספת בשם next הקולטת מחרוזת-חלקית שסופה מצוין ברווח הראשון שהמשתמש מקליד. למשל כתוצאה מביצוע ההוראה הבאה: אם המשתמש מקליד: name = in.next(); העצם name יכיל את המחרוזת:."Moshe" תסתיים בסוף השורה. Moshe Cohen במקרה שהקלט לא כולל תו רווח, המחרוזת ניתן לקלוט מחרוזת באמצעות הפעולות in.nextline או.in.next שטח בזיכרון עבור המחרוזת החדשה. פעולות הקלט מקצות - 3 -

4 9.2 ביצוע פעולות על מחרוזות כדי לבצע פעולות על עצמים יש לרשום את שם העצם, אחריו את סימן הנקודה ולאחר מכן את שם הפעולה. למשל, כדי להגריל מספר הפעלנו את הפעולה nextint על עצם מסוג Random כך: Random rnd = new Random(); int num; num = rnd.nextint(100); במקרה זה הפעולה nextint מחזירה מספר אקראי בין 0 ל- 99 הנשמר במשתנה.num באופן דומה, אפשר להפעיל פעולות שונות על עצמים מסוג מחרוזת. אחת הפעולות המוגדרות עבור מחרוזות היא הפעולה,length המחזירה את אורך המחרוזת שעליה היא מופעלת. למשל, כדי לשמור את אורך המחרוזת s1 במשתנה len נוכל לכתוב: int len; len = s1.length(); הסוגריים שאחרי שם הפעולה נועדו להעברת ערכים (פרמטרים) שהפעולה נזקקת להם. במקרה של הפעולה length אין צורך בהעברת פרמטרים ולכן הסוגריים נותרים ריקים. בהמשך הפרק נכיר פעולות נוספות אשר מצפות לקבל פרמטרים לצורך הפעלתן. בעיה 2 length מטרת הבעיה ו- charat. ופתרונה: הדגמת השימוש בפעולות של מחרוזות. הכרת הפעולות? פתחו וישמו אלגוריתם אשר יקבל כקלט מחרוזת. אם אורך המחרוזת הוא זוגי יוצג כפלט התו הראשון במחרוזת ואם אורך המחרוזת הוא אי-זוגי יוצג התו האחרון במחרוזת. למשל, עבור הקלט shalom יוצג התו: 's'. ועבור הקלט dog יוצג התו: 'g'. שימו : בשפת Java מיקום התווים במחרוזת מתחיל ב- 0. כלומר, התו הראשון במחרוזת נמצא במקום 0, התו השני במחרוזת הוא במקום 1, השלישי במקום 2 וכן הלאה. אם התו הראשון נמצא במקום 0, באיזה מקום נמצא התו האחרון? נתבונן למשל במחרוזת "abcd" שאורכה 4. התו האחרון בה הוא 'd' והוא נמצא במקום 3. מיקום התווים במחרוזת מתחיל ב- 0. בכל מחרוזת, אם נסמן את אורך המחרוזת ב- len אז התו האחרון במחרוזת נמצא במקום.len-1 בחירת משתנים נשתמש במשתנים הבאים: str עצם מהמחלקה מחרוזת char האות המבוקשת, מטיפוס letter len לשמירת אורך המחרוזת, מטיפוס שלם - 4 -

5 str-á 0 str-á len-1 str-á úæåøçî èåì len-á str úæåøçîä ìù äëøåà úà íùä éâåæ len íà íå îá àöîðä åúä úà letter-á íùä 3.1 úøçà íå îá àöîðä åúä úà letter-á íùä 4.1 letter ìù åëøò úà èìôë âöä האלגוריתם יישום האלגוריתם כדי לבדוק את אורכה של המחרוזת נשתמש בפעולה,length באיזו פעולה נשתמש כדי לדעת מהו התו שנמצא במקום מסוים במחרוזת?.charAt(k) פעולה זו במחלקה מחרוזת מוגדרות פעולות נוספות ואחת מהן היא הפעולה מקבלת כפרמטר (בתוך הסוגריים) מספר שלם k, ומחזירה את התו שנמצא במקום ה- k במחרוזת str במחרוזת 0 כדי לדעת מהו התו שנמצא במקום שעליה הופעלה הפעולה. לכן למשל נכתוב: letter = str.charat(0) שימו : השתמשנו פעמים רבות בפעולה זו כאשר קלטנו תו יחיד. למעשה קלטנו מחרוזת וחילצנו ממנה את התו הראשון (התו שנמצא במקום האפס).? התוכנית המלאה /* קלט: מחרוזת פלט: התו הראשון או האחרון במחרוזת, בהתאם לאורכה (זוגי או אי-זוגי ( */ import java.util.scanner; public class IsEven public static void main (String[] args) String str; int len; char letter; Scanner in = new Scanner(System.in); System.out.print("Enter a string: "); str = in.nextline(); len = str.length(); if (len % 2 == 0) letter = str.charat(0); else letter = str.charat(len - 1); System.out.println("The letter is " + letter); } // main } // class IsEven סוף פתרון בעיה 2-5 -

6 בסוף הפרק תוכלו למצוא טבלה המפרטת את הפעולות השכיחות המוגדרות ב- Java עבור עצמים מהמחלקה.String העמודה הימנית בטבלת הפעולות מתארת את שם הפעולה ואת רשימת הפרמטרים שהיא מצפה לקבל (בתוך סוגריים). כפי שראינו זה עתה, הפעולה הראשונה בטבלה length אינה מצפה לקבל ערך כלשהו, ולכן הסוגריים ריקים. לעומתה, הפעולה השנייה charat מצפה לקבל פרמטר אחד מטיפוס שלם. הפעולה השלישית indexof מצפה לקבל עצם מהמחלקה מחרוזת או לקבל תו. העמודה השלישית מתארת את טיפוס הערך המוחזר כתוצאה מהפעלת הפעולה. בדומה לפעולות המתמטיות שלמדנו בפרק 4, גם כאן יש לשים לב לטיפוס הערך המוחזר ולוודא התאמה בינו ובין הפעולות שנבצע עליו. כלומר כאשר נשים בתוך משתנה ערך שמוחזר מפעולה, עלינו לוודא התאמה בין טיפוס הערך המוחזר לטיפוס המשתנה שההשמה תתבצע בו. מחלקות מגדירות אוסף של פעולות שאפשר הפעלת פעולה נכתבת כך (משמאל לימין): להפעיל על עצמים מהמחלקה. (פרמטרים)שם הפעולה.שם העצם יש לבדוק היטב בתיאור הפעולה אילו ערכים היא מצפה לקבל ומה טיפוס הערך שהיא מחזירה. שאלה 9.1 פתחו וישמו אלגוריתם שמקבל כקלט רשימה של 100 מחרוזות. האלגוריתם מחשב בכמה מחרוזות מתוך ה- 100 התו הראשון שווה לתו האחרון, ומציג את הערך שחישב. שאלה 9.2 פתחו אלגוריתם שיקבל כקלט מחרוזת ותו. פלט האלגוריתם יהיה מספר ההופעות של התו הנתון בתוך המחרוזת הנתונה. ישמו את האלגוריתם בשפת.Java הדרכה: מאחר שניתן לברר את אורך המחרוזת הנתונה ניתן להשתמש בהוראה לביצוע-חוזר שמספר הסיבובים בה ידוע מראש (לולאת.(for בעיה 3,String מטרת הבעיה ופתרונה: מחרוזות בתבנית מנייה. הדגמת השימוש בפעולה להשוואת מחרוזת במחלקה ושילוב בסיום בחינות הקבלה למקהלת הזמר העירונית יוצא הבוחן הראשי וקורא את רשימת המועמדים שהתקבלו על פי סדר הא"ב. מועמד אשר שומע את שמו יודע כי התקבל ללהקה. מועמד ששמו עדיין לא נקרא, אשר שומע שם אחר שמופיע אחריו בסדר הא"ב, יודע כי לא התקבל ללהקה. פתחו אלגוריתם אשר הקלט שלו הוא שם מועמד, ולאחר מכן רשימת שמות שקורא הבוחן על פי סדר הא"ב. פלט האלגוריתם הוא אם המועמד התקבל, ומספר השמות שהיה עליו לשמוע לפני שהגיע למסקנה אם התקבל או לא. ישמו את האלגוריתם בשפת.Java - 6 -

7 פירוק הבעיה לתת-משימות למעשה האלגוריתם צריך להשוות מחרוזות ובנוסף לבצע מנייה. אלגוריתם זה דומה לאלגוריתמים שפיתחנו בפרקים קודמים. אם כך, נפרק את הבעיה לתת-משימות הבאות: 1. קליטת שם המועמד קליטת שמות המועמדים שהתקבלו והשוואתם לשם המועמד מניית מספר המחרוזות שנקלטו הצגה אם המועמד התקבל והצגת מספר המחרוזות שהיה עליו לשמוע תת-משימה 3 תבוצע בדומה למשימות מנייה אחרות, ההבדל הוא כמובן בטיפוס הערכים הנמנים מחרוזת במקרה זה ובאופן ביצוע הפעולות עליהם. בשלב יישום האלגוריתם נראה כיצד לעשות זאת. בחירת משתנים האלגוריתם name שם המועמד, עצם מהמחלקה מחרוזת str השם התורן מהקלט, עצם מהמחלקה מחרוזת counter למניית מספר המחרוזות, מטיפוס שלם 1-á counter úà ìçúà name-á úæåøçî èåì str-á úæåøçî èåì :òöá (éðåìéî øãñá) name > str ãåò ìë 1-á counter ìù åëøò úà ìãâä.4.1 str-á úæåøçî èåì.4.2 name = str íà "ìá úä <name> ãîòåîä" èìôë âöä.5.1 úøçà "ìá úä àì <name> ãîòåîä" èìôë âöä.6.1 counter ìù åëøò úà âöä יישום האלגוריתם? כיצד נבדוק אם שם המועמד גדול על פי סדר מילוני מהמחרוזת הנקלטת? אחת הפעולות המוגדרות עבור מחרוזות היא הפעולה CompareTo המשווה מחרוזת למחרוזת נוספת. אם s1 הוא עצם מהמחלקה מחרוזת, ו- s2 הוא עצם נוסף מהמחלקה מחרוזת, אז הביטוי (s2) למחרוזת נוספת המשווה את s1 CompareTo מפעיל את הפעולה s1.compareto(s2) שהתקבלה כפרמטר. הפעולה CompareTo מחזירה את תוצאת ההשוואה כערך שלם באופן הבא: אם המחרוזות שוות יוחזר הערך 0. אם המחרוזת s1 שמופעלת עליה הפעולה, קודמת למחרוזת s2 שהתקבלה כפרמטר בסדר מילוני, יוחזר מספר שלם שלילי

8 ? אם המחרוזת s1 שמופעלת עליה הפעולה, מופיעה אחרי המחרוזת s2 שהתקבלה כפרמטר בסדר מילוני, יוחזר מספר שלם חיובי. לכן, כדי לבדוק אם שם המועמד name גדול מהמחרוזת הנקלטת,str נוכל להשתמש בפעולה.name.compareTo(str) אם הפעולה תחזיר ערך חיובי נדע ששם המועמד גדול מהמחרוזת הנקלטת, ואם היא תחזיר ערך שלילי נדע ששם המועמד קטן מהמחרוזת הנקלטת. אם הפעולה תחזיר 0, נדע שהמחרוזות שוות. כיצד נבדוק אם המחרוזת האחרונה שנקלטה שווה לשם המועמד? אפשר להשתמש שוב בפעולה compareto ולבדוק אם היא מחזירה את הערך 0. לחילופין אפשר לבדוק שוויון של שתי מחרוזות באמצעות הפעולה equals הבודקת שוויון של המחרוזת שעליה היא מופעלת למחרוזת המתקבלת כפרמטר. למשל, הביטוי name.equals(str) יחזיר true אם המחרוזת str שווה למחרוזת,name אחרת יוחזר.false שימו : את המונה נאתחל ב- 1 כיוון שמחוץ ללולאה אנו קולטים את השם הראשון שנקרא. התוכנית המלאה /* קלט: שם מועמד ורשימה ממוינת של שמות פלט: האם המועמד התקבל ומספר השמות שהיה עליו לשמוע */ import java.util.scanner; public class NameFinder public static void main (String[] args) הגדרת משתנים ואתחולם // String name; String str; int counter = 1; קלט שם מבוקש // Scanner in = new Scanner(System.in); System.out.print("Enter the candidate name: "); name = in.nextline(); לולאת זקיף // System.out.print("Enter first winner name: "); str = in.nextline(); כל עוד לא עברנו את שם המועמד // while (name.compareto(str) > 0) counter++; System.out.print("Enter next winner name: "); str = in.nextline(); } // while if (name.equals(str)) System.out.println(name + " is accepted"); else System.out.println(name + " is not accepted"); System.out.println(counter + " Names"); } // main } // class NameFinder - 8 -

9 שימו : לולאת ה- while ממשיכה כל עוד מחרוזות הקלט קטנות משם המועמד. קליטת מחרוזת שווה לשם המועמד או גדולה ממנה גורמת ליציאה מהלולאה. לכן, אחרי הלולאה עלינו לבדוק את סיבת היציאה מהלולאה: האם המחרוזת האחרונה שנקלטה שווה לשם המועמד או גדולה ממנה. 3 פתרון בעיה סוף שאלה 9.3 פתחו אלגוריתם המקבל כקלט רשימת מחרוזות המסתיימת במחרוזת "***". פלט האלגוריתם יהיה אורך המחרוזת הארוכה ביותר ברשימה. ישמו את האלגוריתם בשפת.Java שאלה 9.4 פתחו אלגוריתם שיקבל כקלט שתי מחרוזות ויציג אותן לפי סדר הא"ב. ישמו את האלגוריתם בשפת.Java שאלה 9.5 פתחו וישמו אלגוריתם שיקבל כקלט מילה באנגלית ויציג אותה פעמיים, פעם באותיות גדולות ופעם באותיות קטנות. למשל עבור הקלט Memory הפלט יהיה: MEMORY ומיד אחר-כך.memory חפשו פעולות מתאימות בטבלת הפעולות המופיעה בסוף הפרק. שרשור מחרוזות פעולה נוספת ושימושית מאוד על מחרוזות היא פעולת השׁ ר שׁוּר. פעולה זו מקבלת שתי מחרוזות ויוצרת מחרוזת חדשה, המורכבת מהמחרוזת הראשונה ואחריה מוצמדת המחרוזת השנייה. הפעולה אינה משנה את המחרוזות המקוריות. בשפת Java מתבצע שרשור באמצעות סימן הפעולה +. כלומר, אם s1 ו- s2 הן מחרוזות, אז כדי לשרשר אותן זו לזו נכתוב את הביטוי.s1+s2 למשל, אם ב- s1 נמצאת המחרוזת "he" וב- s2 נמצאת המחרוזת,"llo" אז s1+s2 היא המחרוזת החדשה."hello" שימו : פעולת השרשור אינה פעולה של המחלקה מחרוזת ולכן אופן הפעלתה שונה מזה של פעולות כמו,length כמו charat או כמו פעולות אחרות השייכות למחלקה. היא אינה מופעלת על עצם מהמחלקה, ולכן אין שימוש בסימן הנקודה. אופן הפעלת פעולת השרשור על מחרוזות דומה לאופן הפעלת פעולות מתמטיות על טיפוסים רגילים בשפה. למעשה כבר השתמשנו פעמים רבות בפעולת השרשור על מחרוזות. כזכור, עד כה השתמשנו במחרוזות בהוראות הדפסה כגון: System.out.println("hello"); לעתים, פקודות ההדפסה היו מורכבות מעט יותר. למשל: System.out.println("The number is: " + number) ; או אפילו: System.out.println("There are " + bags + " bags, " + left + " are left over."); בכל ההוראות האלו הפעולה println מקבלת מחרוזת להדפסה. בדוגמה הראשונה המחרוזת היא."hello" בדוגמאות האחרות מועברת לפעולה println מחרוזת שהתקבלה כתוצאה - 9 -

10 מהפעלת פעולת שרשור של מחרוזת ושל משתנה מספרי תוצאת הפעולה מחזירה מחרוזת חדשה. כך למשל המחרוזת ש- println קיבלה בכל אחת משתי הדוגמאות האחרות היא בעצם מחרוזת שהתקבלה כתוצאה מהפעלת פעולת השרשור + (פעם אחת בדוגמה השנייה, וארבע פעמים בשלישית). למשל, אם ערכו של המשתנה number הוא 3, אז המחרוזת שהועברה להדפסה בדוגמה השנייה כלומר המחרוזת,"The number is: " למחרוזת "3" היא שרשור של המחרוזת."The number is: 3" שימו : מאחר שבמשתנה number יש ערך מטיפוס שלם יש להמיר אותו למחרוזת. ואכן טרם השרשור התבצעה פעולת המרה של הערך המספרי למחרוזת המתאימה לו באופן אוטומטי. כך קורה תמיד כאשר נשרשר ערך מטיפוס שאינו מחרוזת למחרוזת. לכן הפעולה println מקבלת למעשה מחרוזת אחת שהיא תוצאת השרשור. לשרשור מחרוזותבאופן הבא: מחרוזת 2 + מחרוזת 1 הפעולה + משמשת פעולת השרשור יוצרת מחרוזת חדשה ומקצה עבורה מקום. היא אינה משפיעה על המחרוזות המקוריות. כאשר משרשרים למחרוזת ערך שאינו מחרוזת, הוא מומר תחילה למחרוזת ואז מתבצעת פעולת השרשור. שאלה 9.6 פתחו אלגוריתם שיקבל כקלט 100 מחרוזות. עבור כל זוג מחרוזות תוצג כפלט מחרוזת שהיא שרשור של שתי המחרוזות עם הסימן '@' ביניהן (כלומר בסך הכול תוצגנה 50 מחרוזות). ישמו את האלגוריתם בשפת.Java ומה בפנים? פעולות המסתכלות אל תוך הקנקן המחלקה מחרוזת מגדירה פעולות שונות המאפשרות להסתכל פנימה לתוך המחרוזת ולהתייחס לתווים המרכיבים אותה. פעולות כאלו, כמו הפעולה charat שכבר הכרנו, מסייעות מאוד בפתרון בעיות שונות, כפי שמדגימה הבעיה הבאה: בעיה 4 מטרת הבעיה ופתרונה: הדגמת השימוש בפעולות המחלצות מידע מתוך מחרוזת. פתחו אלגוריתם שהקלט שלו הוא מחרוזת המהווה משפט באנגלית, והפלט הוא האות האחרונה של המילה הראשונה במשפט ומספר המילים במשפט. למשל, עבור הקלט: day! Welcome to Israel and have a nice הפלט המתאים הוא.e 8 ישמו את האלגוריתם בשפת.Java אפשר להניח שהמשפט מכיל לפחות מילה אחת. ניתוח הבעיה בעזרת דוגמאות נתבונן במשפט שניתן כדוגמה: day!.welcome to Israel and have a nice

11 ? כיצד אפשר לדעת כמה מילים יש במשפט הנתון? כיוון שלפני כל מילה פרט למילה הראשונה יש רווח נוכל למנות את מספר הרווחים במחרוזת ולהוסיף.1 למשל, במשפט day! Welcome to Israel and have a nice יש 7 רווחים, ולכן 8 מילים. (זאת בהנחה שבין מילה למילה יש רווח אחד בלבד!)? מהי האות האחרונה במילה הראשונה? במקרה שהמשפט מכיל מילה אחת בלבד, האות האחרונה במילה הראשונה היא האות האחרונה במחרוזת. בכל שאר המקרים, האות האחרונה במילה הראשונה היא האות שנמצאת מיד לפני הרווח הראשון. פירוק הבעיה לתת-משימות לשם פתרון הבעיה נפתור את התת-משימות הבאות: קליטת המחרוזת מניית מספר הרווחים במחרוזת שנקלטה חישוב מספר המילים במחרוזת מציאת התו האחרון של המילה הראשונה במחרוזת הצגה של מספר המילים במחרוזת ושל התו שנמצא בתת-משימה בחירת משתנים sentence מחרוזת לשמירת המשפט שנקלט numofspaces שלם, מונה את מספר הרווחים במשפט numofwords שלם, שומר את מספר המילים במשפט placeoflastletter שלם, שומר את מיקומו של התו האחרון במילה הראשונה יישום האלגוריתם כדי למנות את מספר הרווחים במחרוזת, נעבור על כל תו במחרוזת ונבדוק אם הוא שווה לרווח. לצורך בדיקת התו במיקום ה- i נשתמש בפעולה charat המחזירה את התו במקום המבוקש: if (sentence.charat(i)==' ') שימו : הפעולה charat מחזירה ערך מטיפוס char ולא מטיפוס מחרוזת, ולכן יש להשוות את הערך המוחזר לתו רווח ' ' (ולא למחרוזת המכילה את התו רווח " "). כדי למצוא את התו האחרון של המילה הראשונה נבדוק את מספר המילים במחרוזת. אם המחרוזת מורכבת ממילה אחת בלבד נחלץ, באמצעות,charAt את התו במקום האחרון, אחרת נחלץ את התו שנמצא לפני הרווח הראשון. כדי למצוא את מיקומו של הרווח הראשון אפשר להשתמש בפעולה indexof המקבלת תו ומחזירה מספר שלם המייצג את מקומו במחרוזת: placeoflastletter = sentence.indexof(' ') - 1; טבלת הפעולות בסוף הפרק מתארת גרסה נוספת של פעולה זו המקבלת מחרוזת ומחזירה את מיקומה בתוך המחרוזת שעליה מופעלת הפעולה. שימו : יש תמיד לדאוג להתאמה בין טיפוסי הערכים שאנו משתמשים בהם ובין אלו המתוארים בכותרת הפעולה

12 התוכנית המלאה /* קלט: משפט באנגלית פלט: האות האחרונה במילה הראשונה ומספר המילים במשפט */ import java.util.scanner; public class HowManyWords public static void main (String[] args) String sentence; int placeoflastletter; int numofspaces = 0; int numofwords; Scanner in = new Scanner(System.in); System.out.println("Enter a sentence, with exactly one " + "space between words:"); sentence = in.nextline(); מניית הרווחים במשפט // for (int i = 0 ; i < sentence.length() ; i++) if (sentence.charat(i) == ' ') numofspaces++; numofwords = numofspaces + 1; מציאת מקומו של הרווח הראשון // if (numofwords == 1) placeoflastletter = sentence.length()- 1; else placeoflastletter = sentence.indexof(' ') - 1; System.out.println("The last letter of the first word is: " + sentence.charat(placeoflastletter)); כמה מילים במשפט // System.out.println("There are " + numofwords + " words"); }//main }// class HowManyWords 4 סוף פתרון בעיה שאלה 9.7 פתחו וישמו אלגוריתם שהקלט שלו הוא תו ומחרוזת והפלט הוא הודעה אם התו נמצא במחרוזת או לא. שאלה 9.8 (מתוך בגרות 1995) פתחו וישמו אלגוריתם הקולט מחרוזת. האלגוריתם מציג כפלט כל תו במחרוזת פעמיים, לתו '*' (כוכבית). גם אם התו כלול במחרוזת הוא לא מוצג כלל. הפלט מוצג בשורה אחת. למשל עבור הקלט: AB*3B*? הפלט יהיה.AABB33BB?? פרט שאלה 9.9 פתחו וישמו אלגוריתם הקולט מחרוזת. האלגוריתם מציג כפלט את המחרוזת ללא אותיות זהות צמודות. למשל עבור הקלט: apple הפלט יהיה:,aple עבור הקלט: Yellow balloon הפלט יהיה: Yelow balon ועבור הקלט: abbba הפלט יהיה:.aba

13 שאלה 9.10 פתחו אלגוריתם שהקלט שלו הוא שלוש מחרוזות, והפלט שלו הוא שלוש המחרוזות לפי סדר מילוני. ישמו את האלגוריתם בשפת.Java למשל עבור הקלט: apple today good הפלט המתאים הוא:.apple good today 9.3 הוראת השמה במחרוזות עד כה ראינו כיצד לבצע פעולות קלט ופלט של מחרוזות, פעולת שרשור ופעולות שונות שמחזירות מידע על המחרוזת. בעיבוד של משתנים רגילים, אחת מהפעולות השימושיות ביותר היא הוראת השמה. בסעיף זה נדון בהשמה עבור מחרוזות, כלומר בהשמה של מחרוזת במשתנה שטיפוסו מחרוזת. למעשה, כפי שכבר אמרנו, גם בעת קליטת מחרוזת אנו מבצעים השמה של המחרוזת הנקלטת, בעצם מסוג מחרוזת. למשל, בהוראה: str = in.nextline(); הפעולה in.nextline מחזירה הפניה לשטח הזיכרון החדש שהוקצה עבור מחרוזת הקלט. בעקבות ההשמה, המשתנה str מפנה אל אותו שטח זיכרון. בסעיף זה נראה דוגמאות נוספות להשמה של מחרוזות. בעיה 5 מטרת הבעיה הבאה: הצגת השמת מחרוזת למחרוזת והדגמה נוספת של השימוש בפעולות של המחלקה.String נאמר שכתובת דואר אלקטרוני היא חוקית אם היא מקיימת את התנאים הבאים: מתחילה באות אנגלית, מורכבת מרצף לא ריק של תווים ואחריו מגיע התו '@', אחריו שוב רצף לא ריק של תווים, אחריו התו '.' ולאחריו עוד רצף לא ריק של תווים. כתובת ישראלית מסתיימת במחרוזת ".il" בקביעת חוקיות של כתובת דואר אין משמעות להבדל בין אותיות גדולות לקטנות. למשל, המחרוזת d@ccv.hhh היא כתובת דואר אלקטרוני חוקית, וכך גם IL.ייי@ t, שהיא כתובת ישראלית. לעומתן, המחרוזות הבאות אינן כתובות חוקיות: cc.יח@ח (לא מתחילה באות אנגלית), tr@.il (רצף התווים שבין התו '@' לבין התו '.' הוא ריק), rt@jjj (לא מכילה את התו '.') sda.asd@sad (התו '.' מופיע לפני התו '@'). פתחו אלגוריתם המקבל כקלט מחרוזת. ניתן להניח כי במחרוזת המתקבלת התו '.' לא מופיע יותר מפעם אחת וכך גם התו '@'. האלגוריתם מציג כפלט את המחרוזת שנקלטה, בצירוף הודעה המבהירה אם המחרוזת מהווה כתובת דואר אלקטרוני חוקית, ואם כן, אם זוהי כתובת ישראלית. ישמו את האלגוריתם בשפת התכנות.Java

14 ניתוח הבעיה בעזרת דוגמאות הכתובת היא חוקית וישראלית. גם הכתובת היא חוקית וישראלית. אין משמעות לשימוש באותיות קטנות או גדולות ההבדל ביניהן אינו משפיע על קביעת חוקיות המחרוזת וגם לא על סיווגה ככתובת ישראלית. אבל הפלט אינו לגמרי זהה בשני המקרים: אמנם בשני המקרים נציג הודעה כי המחרוזת חוקית וישראלית, אך במקרה הראשון נציג את ובמקרה השני את המחרוזת כיוון שבשביל לבדוק את חוקיות המחרוזת וכדי לקבוע אם היא ישראלית או לא אין משמעות להבדל בין אותיות גדולות לקטנות, נוכל לפשט את הבדיקה אם ראשית נמיר את המחרוזת למחרוזת זהה המורכבת מאותיות גדולות או קטנות בלבד, ורק אז נבדוק. נחליט כי המחרוזת האחידה תהיה כולה אותיות קטנות. את מחרוזת הקלט המקורית נשמור כמו שהיא, כדי שנוכל להציגה כפלט. קל לבדוק אם התו הראשון הוא אות אנגלית. ברגע שבדיקה זו הצליחה, כבר ברור שהמילה אינה מתחילה בתו כלומר שהרצף שלפני התו אינו ריק. פירוק הבעיה לתת-משימות קליטת מחרוזת יצירת מחרוזת זהה לזו שנקלטה ובה כל האותיות הן אותיות קטנות בלבד בדיקה שהתו הראשון הוא אות אנגלית בדיקה שהתווים ו-'.' מופיעים במחרוזת בדיקה שהתו '.' מופיע אחרי התו אך לא מיד אחריו ולא בסוף המחרוזת עבור מחרוזת חוקית: בדיקה אם היא ישראלית הצגה של המחרוזת ושל הודעה מלווה מתאימה בחירת משתנים בשאלה מתוארים כמה תנאים שמחרוזת חוקית צריכה לעמוד בהם. מספיק שאחד מהם לא מתקיים כדי לקבוע שהמחרוזת אינה חוקית. נוכל להיעזר במשתנה בוליאני: כל עוד לא מצאנו בעיה בכתובת הדואר האלקטרוני ערכו של המשתנה יהיה.true כאשר נמצא שגיאה באחד התנאים נציב בו.false ההודעה לפלט תוצג לפי ערכו של המשתנה. בנוסף נזדקק לשתי מחרוזות: האחת לשמירת מחרוזת הקלט המקורית, והשנייה לשמירת המחרוזת האחידה. כדי לבדוק את חוקיות המחרוזת נשתמש בשני משתנים שלמים שישמרו את מיקום התווים '.' לבסוף, נקדיש משתנה גם לאורך של המחרוזת שנקלוט. כך נוכל לחשב את האורך פעם אחת, ולהשתמש בערך המשתנה בכל הפעמים שנזדקק לאורך המחרוזת. islegal משתנה בוליאני ("דגל"), שיעיד אם הכתובת היא חוקית או לא str מחרוזת לשמירת הכתובת הנקלטת lowercasestr מחרוזת זהה למחרוזת הקלט ובה כל האותיות הן אותיות קטנות atplace מספר שלם, לשמירת מיקומו של התו dotplace מספר שלם, לשמירת מיקומו של התו '.'

15 האלגוריתם len אורך מחרוזת הקלט true-á islegal êøò úà ìçúà str-á úáåúë èåì,úåðè á úåôìçåî úåìåãâä úåéúåàä ìë äáå str-ì ääæ,äùãç úæåøçî øåö lowercasestr-á äúåà íùäå úéìâðà úåà àì àéä äðåùàøä úåàä íà false-ì islegal êøò úà äðù.4.1 úæåøçîá íéòéôåî íðéà åúä åà '.' åúä íà false-ì islegal êøò úà äðù.5.1 úøçà úæåøçîä óåñá åà åéøçà ãéî åà åúä éðôì òéôåî '.' åúä íà.6.1 false-ì islegal êøò úà äðù true-ì äååù islegal ìù åëøò íà úé åç úáåúëä éë äòãåä èìôë âöä.7.1 ".il" úæåøçîä íä íéðåøçàä íéååúä úùåìù íà.7.2 úéìàøùé úáåúëä éë äòãåä âöä úøçà.7.3 úéìàøùé äðéà úáåúëä éë äòãåä âöä úøçà úé åç äðéà úáåúëä éë äòãåä èìôë âöä יישום האלגוריתם עלינו לבדוק אם התווים '.' מופיעים במחרוזת,str ואם כן אם מיקומם תקין. לשם כך נשתמש בפעולה str.indexof המקבלת תו, ומחזירה את מיקומו במחרוזת.str כדי ליצור ממחרוזת הקלט (השמורה ב- str ) מחרוזת חדשה הזהה לה ובה כל האותיות הן קטנות, נשתמש בפעולה.str.toLowerCase כמו כל פעולה הפועלת על מחרוזות, גם הפעולה tolowercase אינה משנה את המחרוזת שעליה היא מופעלת, אלא יוצרת מחרוזת חדשה. כמו כל פעולה שיוצרת מחרוזת חדשה, הפעולה tolowercase מקצה מקום עבור המחרוזת החדשה. אנו מעוניינים שהמשתנה lowercasestr יפנה למחרוזת החדשה. לכן נשתמש במשפט השמה, ונשים את הערך המוחזר מהפעולה str.tolowercase במשתנה,lowerCaseStr כך: lowercasestr = str.tolowercase(); בעקבות הוראה זאת העצם lowercasestr מפנה אל שטח בזיכרון, ששמורה בו מחרוזת חדשה, הזהה למחרוזת הקלט ובה כל האותיות הן קטנות. במחרוזת המקורית השמורה ב- str לא חל כל שינוי. לא היינו צריכים להקצות במפורש שטח זיכרון לעצם,lowerCaseStr מפני שהפעולה tolowercase הקצתה בעצמה שטח עבור המחרוזת. לאחר פעולת ההשמה העצם lowercasestr מפנה לשטח זה

16 התוכנית המלאה התוכנית מקבלת כקלט מחרוזת, מציגה אותה כפלט, ומציגה גם הודעה המבהירה */ /* אם זו מחרוזת דואר אלקטרוני חוקית, ואם כן, אם היא כתובת ישראלית import java.util.scanner; public class Address public static void main (String[] args) String str; מחרוזת הקלט // מחרוזת כמחרוזת הקלט // lowercasestr; String ובה כל האותיות קטנות // int atplace; שומר מיקום התו // int dotplace; שומר מיקום התו '.' // דגל חוקיות הכתובת // true; boolean islegal = int len; אורך המחרוזת שנקלטה // Scanner in = new Scanner(System.in); קלט מחרוזת ושמירת אורכה // System.out.print("Enter a valid address: "); str = in.nextline(); len = str.length(); יצירת המחרוזת החדשה ושמירתה // lowercasestr = str.tolowercase(); בדיקה שהתו הראשון הוא אות לועזית // if (!(lowercasestr.charat(0) >= 'a' && lowercasestr.charat(0) <= 'z')) islegal = false; מציאת מקום התווים '.' ו -'@' // atplace = lowercasestr.indexof('@'); dotplace = lowercasestr.indexof('.'); אחד משני התווים חסר // -1)) == -1) (atplace if ((dotplace == islegal = false; else if ((dotplace < atplace) (dotplace == atplace + 1) (dotplace == len - 1)) הסדר בין התווים שגוי או שהם מופיעים ברצף // או שהנקודה מופיעה בסוף // islegal = false; הפלט // if (islegal) System.out.println(str + " is a legal address"); בדיקת שלושת התווים האחרונים במחרוזת, האם שווים ל.il- // if (lowercasestr.indexof(".il") == len - 3) System.out.println(" address is Israeli"); else System.out.println(" address is not Israeli"); } else System.out.println(str +" is not a valid address"); } // main } // Address סוף פתרון בעיה

17 s1 = s2; s2. לכן אין צורך לבצע השמת מחרוזות נכתבת כהוראת השמה רגילה: אל אותו שטח זיכרון שאליו מפנה s1 בעקבות ביצוע ההשמה, מפנה קודם הקצאת זיכרון עבור s1. שאלה 9.11 פתחו אלגוריתם המקבל כקלט רשימת מחרוזות המסתיימת במחרוזת."stop" פלט האלגוריתם יהיה המחרוזת הארוכה ביותר ברשימה. ישמו את האלגוריתם בשפת.Java שאלה 9.12 פתחו אלגוריתם המקבל מחרוזת כקלט ומציג אותה בסדר הפוך. למשל עבור הקלט university הפלט יהיה:.ytisrevinu אין צורך ליצור מחרוזת הפוכה אלא רק להציג את התווים שלה בסדר הפוך. ישמו את האלגוריתם בשפת.Java בעיה 6 מטרת הבעיה ופתרונה: הדגמת בניית מחרוזת בשלבים. פתחו אלגוריתם אשר הקלט שלו הוא מחרוזת. הפלט יהיה מחרוזת חדשה, הזהה למחרוזת המקורית, פרט לכך שמופיעה בה האות c בכל מקום שהופיעה האות b או B במחרוזת המקורית. למשל עבור המחרוזת "abcd" הפלט יהיה המחרוזת."accd" שימו : פרט לשינוי המתואר, המחרוזת החדשה צריכה להיות זהה למקורית. לא ניתן להפוך בה אותיות גדולות לקטנות או להפך. פירוק הבעיה לתת-משימות קליטת מחרוזת בניית המחרוזת החדשה הדפסת המחרוזת החדשה את תת-משימה 2 נוכל לפרק באופן הבא: 2.1. יצירת עצם מסוג מחרוזת ואתחולו במחרוזת ריקה 2.2. בנייה הדרגתית של המחרוזת החדשה, תו אחר תו את תת-משימה 2.2 נוכל ליישם בלולאת for ומספר הפעמים לביצועה נקבע לפי אורך המחרוזת. בחירת משתנים str המחרוזת שמתקבלת כקלט newstr המחרוזת החדשה יישום האלגוריתם אתחול העצם newstr במחרוזת ריקה (תת-משימה 2.1) אפשר לבצע יחד עם הצהרת המחרוזת: String newstr = new String("");

18 שמספר הפעמים לביצועה נקבע לפי אורך,for בלולאת 2.2 נוכל ליישם את תת-משימה.charAt ונבנה את הפעולה המחרוזת. בכל פעם נבדוק את התו הבא במחרוזת באמצעות המחרוזת החדשה באמצעות פעולת השרשור, למשל כך: newstr = newstr + 'c'; שימו : פעולת השרשור היא פעולה שמחזירה מחרוזת. כמו כל פעולה שמחזירה מחרוזת, פעולת השרשור אינה משנה את המחרוזות שהיא פועלת עליהן, אלא יוצרת מחרוזת חדשה (כמובן אחרי שהקצתה מקום עבורה), המתקבלת משרשור המחרוזות המקוריות. נניח למשל שב- newstr נמצאת המחרוזת."ad" מה קורה בעת ביצוע הוראת ההשמה שלעיל? פעולת השרשור מקבלת שתי מחרוזות (במקרה זה את newstr ואת המחרוזת "c", אחרי המרת התו 'c' למחרוזת) ויוצרת תוך הקצאת מקום מתאים בזיכרון מחרוזת חדשה שמכילה את שרשור שתי המחרוזות, כלומר את המחרוזת."adc" היא מחזירה את המחרוזת החדשה. בפעולת ההשמה המחרוזת חדשה מושמת ב- newstr. כלומר במקום ש- newstr י פנה אל המחרוזת המקורית,("ad") הוא מפנה כעת אל השטח החדש בזיכרון. מה קרה למחרוזת המקורית? ניתן לומר שהיא הלכה לאיבוד, מכיוון שאין הפניות אליה. בכך פעולת השמה של מחרוזות אינה שונה מפעולת השמה רגילה של משתנים: גם כאשר אנו מבצעים השמה כגון y אובד והערך החדש של x משתנים רגילים, אז ערכו המקורי של שהם ו- y x למשתנים x = y מחליף אותו. כאשר נשרשר למחרוזת תו נוסף, אותו תהליך יחזור על עצמו: הקצאת שטח למחרוזת חדשה שתהיה השרשור של המחרוזת המקורית לתו החדש, והשמה הגורמת ל- newstr להפנות אל השטח בזיכרון של המחרוזת החדשה. אם כך בבנייה הדרגתית של מחרוזת כפי שתואר לעיל, לא יהיה מדויק לומר שאותה מחרוזת גדלה כל פעם בתו נוסף. למעשה, נוצרת סדרה של מחרוזות: בכל פעם נוצרת מחרוזת חדשה, ארוכה בתו אחד, והיא תופסת את מקומה של המחרוזת הקודמת. התוכנית המלאה /* מחרוזת קלט: כל 'B' או 'b' מופיע 'c' ןבמקום מחרוזת זהה למקורית, פלט : */ import java.util.scanner; public class ReplaceCForB public static void main (String[] args) String str; מחרוזת הקלט // String(""); String newstr = new // המחרוזת החדשה במחרוזת ריקה // כעצם המאותחל קלט // Scanner in = new Scanner(System.in); System.out.print("Enter a string: "); str = in.nextline(); בניית המחרוזת החדשה // for(int i = 0; i < str.length(); i++) הקלט תו אחר תו // סריקת מחרוזת

19 if ((str.charat(i) == 'b') (str.charat(i) == 'B')) החלפת 'B' או 'b' ב-' c ' newstr = newstr + 'c'; // else העתקת התו המקורי // str.charat(i); newstr = newstr + } // for פלט // System.out.println("The new String is: " + newstr); } // main } // class ReplaceCForB לבנות מחרוזת חדשה בשלבים, סוף תו אחרי תו פתרון בעיה 6 ניתן לעשות זאת כאשר אנו נדרשים באופן הבא: ליצור עצם שיהיה מחרוזת חדשה ולאתחל אותו במחרוזת ריקה (""); באמצעות הוראה לביצוע-חוזר, לבצע בכל פעם שרשור של המחרוזת הקיימת לתו החדש, והחלפת המחרוזת הקיימת במחרוזת החדשה שהתקבלה מפעולת השרשור. שאלה 9.13 פתחו וישמו אלגוריתם שהקלט שלו הוא מחרוזת המהווה משפט משובש: במקום כל רווח מופיע הסימן $. האלגוריתם מייצר מחרוזת חדשה ובה המשפט התקני, ומציג אותו כפלט. ישמו את האלגוריתם בשפת.Java שאלה 9.14 אורי ונעמי המציאו שפה מוצפנת. המשפטים הניתנים להצפנה כוללים מילים ורווחים בלבד, בהינתן שכל מילה נכתבת רק באותיות אנגליות קטנות. ההצפנה מתבצעת באופן הבא: כל רווח מוחלף בסימן '@', ולאחר כל אות מופיעה האות האנגלית הגדולה המתאימה לה. למשל, המשפט good morning מוצפן כך.gGoOoOdD@mMoOrRnNiInNgG פתחו אלגוריתם המקבל משפט כקלט ומציג את המשפט המוצפן המתאים לו כפלט. ישמו את האלגוריתם בשפת.Java שאלה 9.15 פתחו אלגוריתם שמקבל כקלט מחרוזת, מייצר מחרוזת חדשה ובה סדר התווים הפוך למחרוזת המקורית, ומציג את המחרוזת החדשה כפלט. בנוסף האלגוריתם בודק אם שתי המחרוזות (המקורית וההפוכה) שוות זו לזו. במילים אחרות האלגוריתם בודק אם המחרוזת המקורית היא פלינדרום. האלגוריתם מציג כפלט הודעה מתאימה לתוצאת הבדיקה. למשל: עבור הקלט: dog יהיה הפלט:.god not a palindrome עבור הקלט: aba יהיה הפלט:.aba a palindrome ישמו את האלגוריתם בשפת.Java שאלה 9.16 תלמידי הכיתה התעניינו לדעת למי יש סבתא בשם הארוך ביותר. פתחו אלגוריתם אשר יקבל כקלט את מספר התלמידים בכיתה, ולאחר מכן רשימה של שמות הסבתות של תלמידי הכיתה כמחרוזות. אורך הרשימה כמספר תלמידי הכיתה. פלט האלגוריתם יהיה השם הארוך ביותר. ישמו את האלגוריתם בשפת.Java

20 שאלה 9.17 כתובת אתר אינטרנט של חברה מסחרית בינלאומית בנויה בדרך כלל מ- 3 חלקים המופרדים בנקודות: החברה. www com.שם פתחו אלגוריתם המקבל כקלט כתובת של אתר של חברה מסחרית בינלאומית, במבנה שתואר לעיל, ומציג כפלט את שם החברה בלבד. ישמו את האלגוריתם בשפת.Java הדרכה: השתמשו בפעולה substring שבטבלת הפעולות הנמצאת בסוף הפרק. שאלה 9.18 כתובת אתר אינטרנט של חברה מסחרית שאינה בינלאומית בנויה בדרך כלל מ- 3 חלקים המופרדים בנקודות: סיומת המדינה.שם החברה. www פתחו אלגוריתם המקבל כקלט רשימת כתובות של אתרי חברות מסחריות כאלה (כל אחת מהן במבנה שתואר לעיל). הרשימה תסתיים במחרוזת."end" האלגוריתם יציג כפלט עבור כל חברה את שמה ואת סיומת המדינה שלה. ישמו את האלגוריתם בשפת.Java שאלה 9.19 יעל ועומרי המציאו משחק. כל אחד בתורו רושם משפט המתחיל במילה האחרונה של המשפט מהתור הקודם. המשפט הראשון במשחק יתחיל במילה."start" למשל: start the game game is one of the best ways to kill time time is money פתחו אלגוריתם המסייע למשחקים: האלגוריתם מקבל כקלט את מספר התורות המבוקש. בתחילת כל תור הוא מציג את המילה שצריך להתחיל בה המשפט הבא, ולאחר מכן הוא מקבל כקלט את המשפט החדש. המשחק מסתיים כאשר מספר התורות הסתיים, או כאשר המשפט שבחר אחד השחקנים מתחיל במילה שגויה. ישמו את האלגוריתם בשפת.Java סיכום בפרק זה הכרנו את המחלקה String ולמדנו כיצד לעבד מחרוזות. בשפת Java מחרוזת אינה טיפוס פשוט, כמו int או.char הטיפוס החדש מוגדר בשפה כמחלקה בשם,String ומחרוזות הן עצמים של מחלקה זו. למעשה כבר הכרנו עצמים כאשר השתמשנו במחלקה Random ליצירת מספרים אקראיים. עצמים הם משתנים של הטיפוס החדש ואפשר להפעיל עליהם פעולות המוגדרות במחלקה. אופן השימוש בעצמים שונה מהשימוש במשתנים מהטיפוסים הפשוטים המוכרים לנו. הצהרה על עצם.(char למשל: ממחלקה מסוימת דומה להצהרה על משתנה מטיפוס סטנדרטי (כגון int או String str; בניגוד להצהרה על משתנים מטיפוסים סטנדרטיים, אחרי הצהרה על עצם צריך גם ליצור אותו באמצעות הפעולה.new יצירת העצם כוללת הקצאת שטח זיכרון ואתחול העצם

21 למשל, ההוראה הבאה מקצה מקום עבור str ומאתחלת אותו כך שישמור את המחרוזת "ab" : str = new String("ab"); מכיוון שהשימוש במחרוזות נפוץ כל כך, שפת Java מאפשרת ליצור עצמים מסוג מחרוזת ולאתחל אותם בצורה ישירה ללא שימוש בפעולה.new למשל כך: String s1 = "xyz"; מיקום התווים במחרוזת מתחיל ב- 0. בכל מחרוזת, אם נסמן את אורך המחרוזת ב- len, אז התו האחרון במחרוזת נמצא במיקום,len-1 והתו הראשון נמצא במיקום ה- 0. במחלקה String מוגדרות פעולותשאפשר לבצע על מחרוזות, כלומר על עצמים של המחלקה. לכל פעולה מוגדרים סוגי הערכים (הפרמטרים) שהיא מצפה לקבל, וכן מוגדר טיפוס הערך המוחזר ממנה. חשוב לוודא התאמה של טיפוסי הפרמטרים המועברים לפעולה לאלה שהיא מצפה לקבל, ושל טיפוס הערך המוחזר ממנה לביטוי שהוא משולב בו. למשל, אם אנו מבצעים השמה של הערך המוחזר מפעולה במשתנה, יש לוודא התאמה של טיפוס המשתנה לטיפוס הערך המוחזר. יש פעולות שלא מצפות לקבל פרמטרים ופעולות שלא מחזירות ערך. כדי לציין ביצוע פעולה של עצם מהמחלקה משתמשים בסימון הנקודה: ראשית נכתוב את שם העצם, אחריו נכתוב נקודה, לאחר מכן נכתוב את שם הפעולה לביצוע ומיד אחר כך מפורטים בסוגריים הערכים המועברים לפעולה. למשל: len = str.length(); letter = str.charat(5); עבור עצמים של המחלקה String מוגדרות פעולות רבות, המשמשות אותנו ביישום אלגוריתמים הקשורים למחרוזות. למחלקה זו פעולות רבות נוספות פרט לאלו שהוצגו בפרק. תוכלו למצוא הרחבה על כל אחת מהפעולות בקישור הזה: ביחידה זו נשתמש רק בפעולות שהוצגו בפרק זה. הפעולות שמחזירות מחרוזת, אינן משנות את המחרוזת שהופעלו עליה. הן יוצרות מחרוזת חדשה ומקצות שטח עבורה..Scanner next לביצוע קלט של מחרוזת השתמשנו בפעולה nextline פעולה זו מקצה שטח זיכרון עבור המחרוזת שנקלטה. או של המחלקה גם בעקבות ביצוע השמה של מחרוזת אל מחרוזת, s1, = s2 מפנה s1 אל אותו שטח זיכרון שאליו מפנה s2. לכן אין צורך לבצע קודם הקצאת זיכרון עבור s1. בנוסף לפעולות המוגדרות במחלקה String למדנו בפרק זה על פעולת השרשור. פעולה זו מקבלת שתי מחרוזות ויוצרת מחרוזת חדשה והיא השרשור של שתי המחרוזות. זוהי פעולה שימושית מאוד לצורך הדפסה. פעולת השרשור אינה פעולה של המחלקה String ולכן בכתיבתה אין שימוש בסימון הנקודה. סימן פעולת השרשור הוא הסימן +. בפרקים הבאים נלמד להגדיר מחלקות בעצמנו, ולא רק להשתמש במחלקות קיימות

22 רשימת פעולות על מחרוזות הפעולה תיאור הפעולה טיפוס הערך המוחזר הפעולה דוגמאות הערך המוחזר 3 0 'a' 3 2 s1.length() "dog" פעולה המחזירה את אורכה של המחרוזת (מספר התווים במחרוזת). שלם s1.length() "" פעולה המחזירה את התו הנמצא במחרוזת במיקום (אינדקס) הנתון. תו s1.charat(2) "shalom" s1.indexof("pl") "people" פעולה המקבלת מחרוזת או תו, ומחפשת בתוך המחרוזת שעליה מופעלת הפעולה את המיקום הראשון שבו מופיעה המחרוזת או התו שהתקבלו. הפעולה תחזיר את המיקום. היא תחזיר את הערך -, 1 אם החיפוש נכשל. שלם s1.indexof('o') "people" length() charat(int index) indexof(string s) indexof(char c) false true פעולה המקבלת מחרוזת, ומחזירה true אם המחרוזת שעליה הופעלה הפעולה והמחרוזת שהתקבלה שוות זו לזו בדיוק. אחרת, היא מחזירה בוליאני s1.equals(s2) "love" וב- s2 נמצאת המחרוזת "Love" s1.equals(s2) "love" וב- s2 נמצאת המחרוזת "love".false פעולה המקבלת מחרוזת, ומשווה אותה למחרוזת שעליה הופעלה הפעולה. אם הן שוות זו לזו מוחזר הערך אפס. אם המחרוזת שעליה מופעלת הפעולה קודמת למחרוזת שהתקבלה בסדר מילוני, יוחזר מספר שלם שלילי. אם המחרוזת שעליה מופעלת הפעולה, מופיעה אחרי המחרוזתשהתקבלה בסדר מילוני, יוחזר מספר שלם חיובי. שלם s1.compareto(s2) "aa" וב- s2 נמצאת המחרוזת מספר שלילי כלשהו "ab" equals(string s) compareto(string s)

23 פעולה שיוצרת מחרוזת זהה למחרוזת שעליה היא מופעלת, ובה כל האותיות מוחלפות באותיות קטנות. הפעולה מחזירה את המחרוזת החדשה. מחרוזת s1.tolowercase() המחרוזת החדשה "peace" "Peace" tolowercase() פעולה שיוצרת מחרוזת זהה למחרוזת שעליה היא מופעלת, ובה כל האותיות מוחלפות באותיות גדולות. הפעולה מחזירה את המחרוזת החדשה. מחרוזת מחרוזת מחרוזת s1.touppercase() המחרוזת החדשה "PEACE" "Peace" פעולה שיוצרת מחרוזת זהה לתת-מחרוזת המתחילה מהמקום ה- k של המחרוזת שעליה הפעולה מופעלת ועד סופה. הפעולה מחזירה את המחרוזת החדשה. s1.substring(4) המחרוזת החדשה "Bye" "GoodBye" פעולה שיוצרת מחרוזת זהה לתת-מחרוזת המתחילה מהמקום ה- k של המחרוזת שעליה הפעולהמופעלת, ועד המקום ה-( s-1 ). הפעולה מחזירה את המחרוזת החדשה. שימו לב שעל ערכו של s להיות קטן או שווה לאורך המחרוזת. s1.substring(4,10) המחרוזת החדשה "Bye Is" "GoodBye Israel" touppercase() substring(int k) substring(int k, int s)